/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk<ymnk@jcraft.com>
 *   
 * Many thanks to 
 *   Monty <monty@xiph.org> and 
 *   The XIPHOPHORUS Company http://www.xiph.org/ .
 * JOrbis has been based on their awesome works, Vorbis codec.
 *   
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package com.jcraft.jorbis;

import com.jcraft.jogg.*;

class StaticCodeBook
{
	int dim; // codebook dimensions (elements per vector)
	int entries; // codebook entries
	int[] lengthlist; // codeword lengths in bits

	// mapping
	int maptype; // 0=none
	// 1=implicitly populated values from map column
	// 2=listed arbitrary values

	// The below does a linear, single monotonic sequence mapping.
	int q_min; // packed 32 bit float; quant value 0 maps to minval
	int q_delta; // packed 32 bit float; val 1 - val 0 == delta
	int q_quant; // bits: 0 < quant <= 16
	int q_sequencep; // bitflag

	// additional information for log (dB) mapping; the linear mapping
	// is assumed to actually be values in dB. encodebias is used to
	// assign an error weight to 0 dB. We have two additional flags:
	// zeroflag indicates if entry zero is to represent -Inf dB; negflag
	// indicates if we're to represent negative linear values in a
	// mirror of the positive mapping.

	int[] quantlist; // map == 1: (int)(entries/dim) element column map

	// map == 2: list of dim*entries quantized entry vals

	StaticCodeBook()
	{
	}

	int pack(Buffer opb)
	{
		int i;
		boolean ordered = false;

		opb.write(0x564342, 24);
		opb.write(dim, 16);
		opb.write(entries, 24);

		// pack the codewords. There are two packings; length ordered and
		// length random. Decide between the two now.

		for (i = 1; i < entries; i++)
		{
			if (lengthlist[i] < lengthlist[i - 1])
				break;
		}
		if (i == entries)
			ordered = true;

		if (ordered)
		{
			// length ordered. We only need to say how many codewords of
			// each length. The actual codewords are generated
			// deterministically

			int count = 0;
			opb.write(1, 1); // ordered
			opb.write(lengthlist[0] - 1, 5); // 1 to 32

			for (i = 1; i < entries; i++)
			{
				int _this = lengthlist[i];
				int _last = lengthlist[i - 1];
				if (_this > _last)
				{
					for (int j = _last; j < _this; j++)
					{
						opb.write(i - count, Util.ilog(entries - count));
						count = i;
					}
				}
			}
			opb.write(i - count, Util.ilog(entries - count));
		} else
		{
			// length random. Again, we don't code the codeword itself, just
			// the length. This time, though, we have to encode each length
			opb.write(0, 1); // unordered

			// algortihmic mapping has use for 'unused entries', which we tag
			// here. The algorithmic mapping happens as usual, but the unused
			// entry has no codeword.
			for (i = 0; i < entries; i++)
			{
				if (lengthlist[i] == 0)
					break;
			}

			if (i == entries)
			{
				opb.write(0, 1); // no unused entries
				for (i = 0; i < entries; i++)
				{
					opb.write(lengthlist[i] - 1, 5);
				}
			} else
			{
				opb.write(1, 1); // we have unused entries; thus we tag
				for (i = 0; i < entries; i++)
				{
					if (lengthlist[i] == 0)
					{
						opb.write(0, 1);
					} else
					{
						opb.write(1, 1);
						opb.write(lengthlist[i] - 1, 5);
					}
				}
			}
		}

		// is the entry number the desired return value, or do we have a
		// mapping? If we have a mapping, what type?
		opb.write(maptype, 4);
		switch (maptype)
		{
			case 0:
				// no mapping
				break;
			case 1:
			case 2:
				// implicitly populated value mapping
				// explicitly populated value mapping
				if (quantlist == null)
				{
					// no quantlist? error
					return (-1);
				}

				// values that define the dequantization
				opb.write(q_min, 32);
				opb.write(q_delta, 32);
				opb.write(q_quant - 1, 4);
				opb.write(q_sequencep, 1);

				{
					int quantvals = 0;
					switch (maptype)
					{
						case 1:
							// a single column of (c->entries/c->dim) quantized
							// values for
							// building a full value list algorithmically
							// (square lattice)
							quantvals = maptype1_quantvals();
							break;
						case 2:
							// every value (c->entries*c->dim total) specified
							// explicitly
							quantvals = entries * dim;
							break;
					}

					// quantized values
					for (i = 0; i < quantvals; i++)
					{
						opb.write(Math.abs(quantlist[i]), q_quant);
					}
				}
				break;
			default:
				// error case; we don't have any other map types now
				return (-1);
		}
		return (0);
	}

	// unpacks a codebook from the packet buffer into the codebook struct,
	// readies the codebook auxiliary structures for decode
	int unpack(Buffer opb)
	{
		int i;
		// memset(s,0,sizeof(static_codebook));

		// make sure alignment is correct
		if (opb.read(24) != 0x564342)
		{
			// goto _eofout;
			clear();
			return (-1);
		}

		// first the basic parameters
		dim = opb.read(16);
		entries = opb.read(24);
		if (entries == -1)
		{
			// goto _eofout;
			clear();
			return (-1);
		}

		// codeword ordering.... length ordered or unordered?
		switch (opb.read(1))
		{
			case 0:
				// unordered
				lengthlist = new int[entries];

				// allocated but unused entries?
				if (opb.read(1) != 0)
				{
					// yes, unused entries

					for (i = 0; i < entries; i++)
					{
						if (opb.read(1) != 0)
						{
							int num = opb.read(5);
							if (num == -1)
							{
								// goto _eofout;
								clear();
								return (-1);
							}
							lengthlist[i] = num + 1;
						} else
						{
							lengthlist[i] = 0;
						}
					}
				} else
				{
					// all entries used; no tagging
					for (i = 0; i < entries; i++)
					{
						int num = opb.read(5);
						if (num == -1)
						{
							// goto _eofout;
							clear();
							return (-1);
						}
						lengthlist[i] = num + 1;
					}
				}
				break;
			case 1:
				// ordered
			{
				int length = opb.read(5) + 1;
				lengthlist = new int[entries];

				for (i = 0; i < entries;)
				{
					int num = opb.read(Util.ilog(entries - i));
					if (num == -1)
					{
						// goto _eofout;
						clear();
						return (-1);
					}
					for (int j = 0; j < num; j++, i++)
					{
						lengthlist[i] = length;
					}
					length++;
				}
			}
				break;
			default:
				// EOF
				return (-1);
		}

		// Do we have a mapping to unpack?
		switch ((maptype = opb.read(4)))
		{
			case 0:
				// no mapping
				break;
			case 1:
			case 2:
				// implicitly populated value mapping
				// explicitly populated value mapping
				q_min = opb.read(32);
				q_delta = opb.read(32);
				q_quant = opb.read(4) + 1;
				q_sequencep = opb.read(1);

				{
					int quantvals = 0;
					switch (maptype)
					{
						case 1:
							quantvals = maptype1_quantvals();
							break;
						case 2:
							quantvals = entries * dim;
							break;
					}

					// quantized values
					quantlist = new int[quantvals];
					for (i = 0; i < quantvals; i++)
					{
						quantlist[i] = opb.read(q_quant);
					}
					if (quantlist[quantvals - 1] == -1)
					{
						// goto _eofout;
						clear();
						return (-1);
					}
				}
				break;
			default:
				// goto _eofout;
				clear();
				return (-1);
		}
		// all set
		return (0);
		// _errout:
		// _eofout:
		// vorbis_staticbook_clear(s);
		// return(-1);
	}

	// there might be a straightforward one-line way to do the below
	// that's portable and totally safe against roundoff, but I haven't
	// thought of it. Therefore, we opt on the side of caution
	private int maptype1_quantvals()
	{
		int vals = (int) (Math.floor(Math.pow(entries, 1. / dim)));

		// the above *should* be reliable, but we'll not assume that FP is
		// ever reliable when bitstream sync is at stake; verify via integer
		// means that vals really is the greatest value of dim for which
		// vals^b->bim <= b->entries
		// treat the above as an initial guess
		while (true)
		{
			int acc = 1;
			int acc1 = 1;
			for (int i = 0; i < dim; i++)
			{
				acc *= vals;
				acc1 *= vals + 1;
			}
			if (acc <= entries && acc1 > entries)
			{
				return (vals);
			} else
			{
				if (acc > entries)
				{
					vals--;
				} else
				{
					vals++;
				}
			}
		}
	}

	void clear()
	{
	}

	// unpack the quantized list of values for encode/decode
	// we need to deal with two map types: in map type 1, the values are
	// generated algorithmically (each column of the vector counts through
	// the values in the quant vector). in map type 2, all the values came
	// in in an explicit list. Both value lists must be unpacked
	float[] unquantize()
	{

		if (maptype == 1 || maptype == 2)
		{
			int quantvals;
			float mindel = float32_unpack(q_min);
			float delta = float32_unpack(q_delta);
			float[] r = new float[entries * dim];

			// maptype 1 and 2 both use a quantized value vector, but
			// different sizes
			switch (maptype)
			{
				case 1:
					// most of the time, entries%dimensions == 0, but we need to
					// be
					// well defined. We define that the possible vales at each
					// scalar is values == entries/dim. If entries%dim != 0,
					// we'll
					// have 'too few' values (values*dim<entries), which means
					// that
					// we'll have 'left over' entries; left over entries use
					// zeroed
					// values (and are wasted). So don't generate codebooks like
					// that
					quantvals = maptype1_quantvals();
					for (int j = 0; j < entries; j++)
					{
						float last = 0.f;
						int indexdiv = 1;
						for (int k = 0; k < dim; k++)
						{
							int index = (j / indexdiv) % quantvals;
							float val = quantlist[index];
							val = Math.abs(val) * delta + mindel + last;
							if (q_sequencep != 0)
								last = val;
							r[j * dim + k] = val;
							indexdiv *= quantvals;
						}
					}
					break;
				case 2:
					for (int j = 0; j < entries; j++)
					{
						float last = 0.f;
						for (int k = 0; k < dim; k++)
						{
							float val = quantlist[j * dim + k];
							// if((j*dim+k)==0){System.err.println(" | 0 -> "+val+" | ");}
							val = Math.abs(val) * delta + mindel + last;
							if (q_sequencep != 0)
								last = val;
							r[j * dim + k] = val;
							// if((j*dim+k)==0){System.err.println(" $ r[0] -> "+r[0]+" | ");}
						}
					}
					// System.err.println("\nr[0]="+r[0]);
			}
			return (r);
		}
		return (null);
	}

	// 32 bit float (not IEEE; nonnormalized mantissa +
	// biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm
	// Why not IEEE? It's just not that important here.

	static final int VQ_FEXP = 10;
	static final int VQ_FMAN = 21;
	static final int VQ_FEXP_BIAS = 768; // bias toward values smaller than 1.

	// doesn't currently guard under/overflow
	static long float32_pack(float val)
	{
		int sign = 0;
		int exp;
		int mant;
		if (val < 0)
		{
			sign = 0x80000000;
			val = -val;
		}
		exp = (int) Math.floor(Math.log(val) / Math.log(2));
		mant = (int) Math.rint(Math.pow(val, (VQ_FMAN - 1) - exp));
		exp = (exp + VQ_FEXP_BIAS) << VQ_FMAN;
		return (sign | exp | mant);
	}

	static float float32_unpack(int val)
	{
		float mant = val & 0x1fffff;
		float exp = (val & 0x7fe00000) >>> VQ_FMAN;
		if ((val & 0x80000000) != 0)
			mant = -mant;
		return (ldexp(mant, ((int) exp) - (VQ_FMAN - 1) - VQ_FEXP_BIAS));
	}

	static float ldexp(float foo, int e)
	{
		return (float) (foo * Math.pow(2, e));
	}
}
